package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"ginstudydemo.com/main/cache"
	"github.com/redis/go-redis/v9"
	"time"
)

type IAuthService interface {
	AddTokenToBlacklist()
	IsTokenBlacklisted()
}

type AuthService struct{}

func NewAuthService() *AuthService {
	return &AuthService{}
}

// AddTokenToBlacklist 将JWT token添加到黑名单，并设置过期时间
func (a AuthService) AddTokenToBlacklist(token string, expiration time.Duration) error {
	return cache.Rdb.Set(cache.Rctx, token, "blacklisted", expiration).Err()
}

// IsTokenBlacklisted 检查JWT token是否在黑名单中
func (a AuthService) IsTokenBlacklisted(token string) (bool, error) {
	_, err := cache.Rdb.Get(cache.Rctx, token).Result()
	if errors.Is(err, redis.Nil) {
		return false, nil // token 不存在于黑名单中
	}
	if err != nil {
		return false, err // 出现错误
	}
	return true, nil // token 在黑名单中
}

// SavePermsAsGoHashSetToRedis 将权限列表存入 Redis 哈希表
func (a AuthService) SavePermsAsGoHashSetToRedis(roleCode string, perms []string) error {
	hashKey := "role_perms" // Redis 哈希表的键名
	field := roleCode       // 哈希表的字段名，即角色代码

	// 创建一个 Go HashSet 格式的字符串
	hashSetFormat := []interface{}{"go.util.HashSet", perms}

	// 将 hashSetFormat 转换为 JSON 字符串
	value, err := json.Marshal(hashSetFormat)
	if err != nil {
		return err
	}

	// 将 JSON 字符串存入 Redis 哈希表中
	err = cache.Rdb.HSet(cache.Rctx, hashKey, field, value).Err()
	if err != nil {
		return err
	}

	// 可选：设置哈希表的过期时间，例如 24 小时
	err = cache.Rdb.Expire(cache.Rctx, hashKey, 24*time.Hour).Err()
	if err != nil {
		return err
	}

	fmt.Printf("Perms for role %s saved to Redis as Go HashSet: %s\n", roleCode, string(value))
	return nil
}

// GetPermsFromRedis 从 Redis 哈希表中取出权限列表
func (a AuthService) GetPermsFromRedis(roleCode string) ([]string, error) {
	hashKey := "role_perms" // Redis 哈希表的键名
	field := roleCode       // 哈希表的字段名，即角色代码

	// 从 Redis 哈希表中获取 JSON 字符串
	value, HGetErr := cache.Rdb.HGet(cache.Rctx, hashKey, field).Result()
	if errors.Is(HGetErr, redis.Nil) {
		fmt.Printf("No perms found for role %s\n", roleCode)
		return nil, nil // 如果没有找到对应的权限列表，返回 nil
	} else if HGetErr != nil {
		return nil, HGetErr
	}

	// 解析 JSON 字符串，提取权限列表
	var hashSetFormat []interface{}
	HGetErr = json.Unmarshal([]byte(value), &hashSetFormat)
	if HGetErr != nil {
		return nil, HGetErr
	}

	// 提取权限列表
	perms, ok := hashSetFormat[1].([]interface{})
	if !ok {
		return nil, fmt.Errorf("invalid format for role %s permissions", roleCode)
	}

	// 转换 []interface{} 为 []string
	permsList := make([]string, len(perms))
	for i, perm := range perms {
		permsList[i], ok = perm.(string)
		if !ok {
			return nil, fmt.Errorf("invalid permission format for role %s", roleCode)
		}
	}

	fmt.Printf("Perms for role %s retrieved from Redis: %v\n", roleCode, permsList)
	return permsList, nil
}
